package com.ruoyi.aero.service.impl;

import java.util.ArrayList;
import java.util.List;

import com.ruoyi.aero.domain.GroupInfo;
import com.ruoyi.aero.enums.SysPostCode;
import com.ruoyi.aero.service.IGroupInfoService;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.uuid.IdUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ruoyi.aero.mapper.StaffInfoMapper;
import com.ruoyi.aero.domain.StaffInfo;
import com.ruoyi.aero.service.IStaffInfoService;
import org.springframework.util.ObjectUtils;

/**
 * 员工信息Service业务层处理
 * 
 * @author swb
 * @date 2024-06-04
 */
@Service
public class StaffInfoServiceImpl implements IStaffInfoService 
{
    @Autowired
    private StaffInfoMapper staffInfoMapper;

    @Autowired
    private IGroupInfoService groupInfoService;

    /**
     * 查询员工信息
     * 
     * @param staffId 员工信息主键
     * @return 员工信息
     */
    @Override
    public StaffInfo selectStaffInfoByStaffId(String staffId)
    {
        return staffInfoMapper.selectStaffInfoByStaffId(staffId);
    }

    /**
     * 查询厂长信息
     * @return
     */
    @Override
    public StaffInfo selectDirector() {
        return staffInfoMapper.selectDirector();
    }

    /**
     * 查询员工信息
     *
     * @param staffNo 员工信息编码
     * @return 员工信息
     */
    @Override
    public StaffInfo selectStaffInfoByStaffNo(String staffNo)
    {
        return staffInfoMapper.selectStaffInfoByStaffNo(staffNo);
    }

    /**
     * 查询员工信息列表
     * 
     * @param staffInfo 员工信息
     * @return 员工信息
     */
    @Override
    public List<StaffInfo> selectStaffInfoList(StaffInfo staffInfo)
    {
        return staffInfoMapper.selectStaffInfoList(staffInfo);
    }

    /**
     * 查询员工信息列表
     *
     * @param postNo 员工信息
     * @return 员工信息
     */
    @Override
    public List<StaffInfo> selectStaffInfoListByPost(String postNo) {
        if ("all".equals(postNo)) {
            // 如果前端传递all，则代表查询所有在职员工
            StaffInfo staffInfo = new StaffInfo();
            staffInfo.setWorking("Y");
            return staffInfoMapper.selectStaffInfoList(staffInfo);
        }

        return staffInfoMapper.selectStaffInfoListByPost(postNo);
    }

    /**
     * 查询车间负责人候选人
     *
     * @return 员工信息集合
     */
    @Override
    public List<StaffInfo> selectWorkshopCandidate() {
        return staffInfoMapper.selectWorkshopCandidate();
    }

    /**
     * 查询班组负责人候选人
     *
     * @return 员工信息集合
     */
    @Override
    public List<StaffInfo> selectGroupCandidate() {
        return staffInfoMapper.selectGroupCandidate();
    }

    /**
     * 新增员工信息
     * 
     * @param staffInfo 员工信息
     * @return 结果
     */
    @Override
    public int insertStaffInfo(StaffInfo staffInfo)
    {
        if ("Y".equals(staffInfo.getWorking())) {
            repeatDirector(staffInfo);
            repeatStaffNo(staffInfo);
            repeatPhone(staffInfo);
        }
        markByPost(staffInfo);
        staffInfo.setStaffId(IdUtils.randomUUID());
        staffInfo.setCreateTime(DateUtils.getNowDate());
        staffInfo.setCreateBy(SecurityUtils.getUsername());
        return staffInfoMapper.insertStaffInfo(staffInfo);
    }

    /**
     * 修改员工信息
     * 
     * @param staffInfo 员工信息
     * @return 结果
     */
    @Override
    public int updateStaffInfo(StaffInfo staffInfo)
    {
        if ("Y".equals(staffInfo.getWorking())) {
            repeatDirector(staffInfo);
            repeatStaffNo(staffInfo);
            repeatPhone(staffInfo);
        }
        canRemove(staffInfo);
        markByPost(staffInfo);
        staffInfo.setUpdateTime(DateUtils.getNowDate());
        staffInfo.setUpdateBy(SecurityUtils.getUsername());
        return staffInfoMapper.updateStaffInfo(staffInfo);
    }

    /**
     * 批量删除员工信息
     * 
     * @param staffIds 需要删除的员工信息主键
     * @return 结果
     */
    @Override
    public int deleteStaffInfoByStaffIds(String[] staffIds)
    {
        return staffInfoMapper.deleteStaffInfoByStaffIds(staffIds);
    }

    /**
     * 删除员工信息信息
     * 
     * @param staffId 员工信息主键
     * @return 结果
     */
    @Override
    public int deleteStaffInfoByStaffId(String staffId)
    {
        return staffInfoMapper.deleteStaffInfoByStaffId(staffId);
    }

    /**
     * 判断员工编码是否重复
     */
    private void repeatStaffNo(StaffInfo staffInfo) {
        String staffId = staffInfo.getStaffId();
        String staffNo = staffInfo.getStaffNo();
        if (ObjectUtils.isEmpty(staffNo)) {
            throw new ServiceException("员工编码不能为空，操作失败");
        }

        StaffInfo staff = selectStaffInfoByStaffNo(staffNo);
        if (ObjectUtils.isEmpty(staff)) {
            // 如果为空，则代表没有重复，直接返回
            return;
        }

        if (ObjectUtils.isEmpty(staffId)) {
            // 添加操作，直接判定重复
            throw new ServiceException("员工编码与已有信息重复，操作失败");
        } else {
            // 修改操作，比较id是否一致
            if (!staff.getStaffId().equals(staffId)) {
                // 若id不一致，则与其他员工编码重复
                throw new ServiceException("员工编码与已有信息重复，操作失败");
            }
        }
    }

    /**
     * 根据岗位对所属车间或所属班组做标记
     * @param staffInfo
     */
    private void markByPost(StaffInfo staffInfo) {
        String staffId = staffInfo.getStaffId();
        String postNo = staffInfo.getPostNo();
        if (ObjectUtils.isEmpty(postNo)) {
            throw new ServiceException("未指定岗位，操作失败");
        }

        if (!ObjectUtils.isEmpty(staffId)) {
            StaffInfo staff = selectStaffInfoByStaffId(staffId);
            if (!postNo.equals(staff.getPostNo())) {
                // 如果岗位发生改变
                if (SysPostCode.WORK_SHOP_DIRECTOR.getPostCode().equals(staff.getPostNo())) {
                    // 如果原先是车间主任
                    if (!ObjectUtils.isEmpty(staff.getWorkshopId()) && !"无".equals(staff.getWorkshopId())) {
                        // 并且这个车间主任还负责了车间
                        throw new ServiceException("此员工正在负责车间，无法修改岗位");
                    }
                } else if (SysPostCode.TEAM_LEADER.getPostCode().equals(staff.getPostNo())) {
                    // 如果原先是班组长
                    if (!ObjectUtils.isEmpty(staff.getGroupId()) && !"无".equals(staff.getGroupId())) {
                        // 并且这个班组长还负责了班组
                        throw new ServiceException("此员工正在负责班组，无法修改岗位");
                    }
                }
            }
        }

        if (SysPostCode.DIRECTOR.getPostCode().equals(postNo)) {
            // 如果是厂长，则去掉所属班组id和所属车间id
            staffInfo.setWorkshopId("无");
            staffInfo.setGroupId("无");
        } else if (SysPostCode.WORK_SHOP_DIRECTOR.getPostCode().equals(postNo)){
            // 如果是车间主任，则设置所属车间id，班组id去掉
            if (ObjectUtils.isEmpty(staffInfo.getWorkshopId())) return;
            staffInfo.setWorkshopId(staffInfo.getWorkshopId());
            staffInfo.setGroupId("无");
        } else {
            // 如果是班组长或普通员工，则双属性均设置
            String groupId = staffInfo.getGroupId();
            if (ObjectUtils.isEmpty(groupId)) return;
            GroupInfo groupInfo = groupInfoService.selectGroupInfoByGroupId(groupId);
            staffInfo.setWorkshopId(groupInfo.getWorkshopId());
        }
    }

    /**
     * 判断员工手机号是否重复
     * @param staffInfo
     */
    private void repeatPhone(StaffInfo staffInfo) {
        String staffId = staffInfo.getStaffId();
        String phone = staffInfo.getPhone();
        if (ObjectUtils.isEmpty(phone)) {
            throw new ServiceException("手机号不能为空，操作失败");
        }

        StaffInfo staff = staffInfoMapper.selectStaffInfoByPhone(phone);
        if (ObjectUtils.isEmpty(staff)) {
            // 如果为空，则代表没有重复，直接返回
            return;
        }

        if (ObjectUtils.isEmpty(staffId)) {
            // 添加操作，直接判定重复
            throw new ServiceException("员工手机号与其他员工重复，操作失败");
        } else {
            // 修改操作，比较id是否一致
            if (!staff.getStaffId().equals(staffId)) {
                // 若id不一致，则重复
                throw new ServiceException("员工手机号与其他员工重复，操作失败");
            }
        }
    }

    /**
     * 判断厂长是否唯一
     */
    private void repeatDirector(StaffInfo staffInfo) {
        String staffId = staffInfo.getStaffId();
        String postNo = staffInfo.getPostNo();
        if (SysPostCode.DIRECTOR.getPostCode().equals(postNo)) {
            StaffInfo staff = selectDirector();
            if (ObjectUtils.isEmpty(staff)) return;
            if (ObjectUtils.isEmpty(staffId)) {
                throw new ServiceException("只能有一个厂长，操作失败");
            }
            if (!staff.getStaffId().equals(staffId)) {
                throw new ServiceException("只能有一个厂长，操作失败");
            }
        }
    }

    /**
     * 判断能否设为离职
     * @param staffInfo
     */
    private void canRemove(StaffInfo staffInfo) {
        if ("N".equals(staffInfo.getWorking())) {
            // 如果改为离职
            String staffId = staffInfo.getStaffId();
            StaffInfo staff = selectStaffInfoByStaffId(staffId);
            if (!SysPostCode.STAFF.getPostCode().equals(staff.getPostNo())) {
                throw new ServiceException("只有普通员工才能改为离职，其余员工需先解除负责内容，降为普通员工后将其离职");
            }
        }
    }
}
